diff --git a/user_guide/general/autoloader.html b/user_guide/general/autoloader.html
index a7e907e..36893e9 100644
--- a/user_guide/general/autoloader.html
+++ b/user_guide/general/autoloader.html
@@ -92,7 +92,7 @@
 
 <div id="footer">
 <p>
-Previous Topic:&nbsp;&nbsp;<a href="hooks.html">Hooks - Extneding the Core</a>
+Previous Topic:&nbsp;&nbsp;<a href="hooks.html">Hooks - Extending the Core</a>
 &nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="#top">Top of Page</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
 <a href="../index.html">User Guide Home</a>&nbsp;&nbsp;&nbsp;&middot;&nbsp;&nbsp;
diff --git a/user_guide/general/errors.html b/user_guide/general/errors.html
index 72c9120..16db19e 100644
--- a/user_guide/general/errors.html
+++ b/user_guide/general/errors.html
@@ -112,7 +112,7 @@
 <ol>
 <li>Error Messages.  These are actual errors, such as PHP errors or user errors.</li>
 <li>Debug Messages.  These are messages that assist in debugging. For example, if a class has been initialized, you could log this as debugging info.</li>
-<li>Informational Messages.  These are the lowest priority messages, simply giving information regarding some process.  Code Igniter doesn't natively generate any info messsages but you may want to in your application.</li>
+<li>Informational Messages.  These are the lowest priority messages, simply giving information regarding some process.  Code Igniter doesn't natively generate any info messages but you may want to in your application.</li>
 </ol>
 
 
diff --git a/user_guide/general/helpers.html b/user_guide/general/helpers.html
index a0042b5..089d6d0 100644
--- a/user_guide/general/helpers.html
+++ b/user_guide/general/helpers.html
@@ -76,7 +76,7 @@
 
 <p>Helpers are typically stored in your <dfn>system/helpers</dfn> directory.  Alternately you can create a folder called <kbd>helpers</kbd> inside
 your <kbd>application</kbd> folder and store them there.  Code Igniter will look first in your <dfn>system/application/helpers</dfn>
-directory.  If the direcotry does not exist or the specified helper is not located there CI will instead look in your global 
+directory.  If the directory does not exist or the specified helper is not located there CI will instead look in your global 
 <dfn>system/helpers</dfn> folder.</p>
 
 
diff --git a/user_guide/general/plugins.html b/user_guide/general/plugins.html
index 2e603dd..78b8231 100644
--- a/user_guide/general/plugins.html
+++ b/user_guide/general/plugins.html
@@ -64,12 +64,12 @@
 <h1>Plugins</h1>
 
 <p>Plugins work almost identically to <a href="helpers.html">Helpers</a>.  The main difference is that a plugin usually 
-provides a single function, whereas a Helper is usually a collection of functions.  Helpers are also considerd a part of
+provides a single function, whereas a Helper is usually a collection of functions.  Helpers are also considered a part of
 the core system; plugins are intended to be created and shared by our community.</p>
 
 <p>Plugins should be saved to your <dfn>system/plugins</dfn> directory or you can create a folder called <kbd>plugins</kbd> inside
 your <kbd>application</kbd> folder and store them there.  Code Igniter will look first in your <dfn>system/application/plugins</dfn>
-directory.  If the direcotry does not exist or the specified plugin is not located there CI will instead look in your global 
+directory.  If the directory does not exist or the specified plugin is not located there CI will instead look in your global 
 <dfn>system/plugins</dfn> folder.</p>
 
 
diff --git a/user_guide/general/profiling.html b/user_guide/general/profiling.html
index 42cba04..880aa0c 100644
--- a/user_guide/general/profiling.html
+++ b/user_guide/general/profiling.html
@@ -74,7 +74,7 @@
 
 <h2>Enabling the Profiler</h2>
 
-<p>To enable the profiler place the the following function anywhere within your <a href="controllers.html">Controller</a> functions:</p>
+<p>To enable the profiler place the following function anywhere within your <a href="controllers.html">Controller</a> functions:</p>
 <code>$this->output->enable_profiler(TRUE);</code>
 
 <p>When enabled a report will be generated and inserted at the bottom of your pages.</p>
diff --git a/user_guide/general/urls.html b/user_guide/general/urls.html
index e62ac2f..b3b842d 100644
--- a/user_guide/general/urls.html
+++ b/user_guide/general/urls.html
@@ -112,7 +112,7 @@
 
 <code>www.your-site.com/index.php/products/view/shoes</code>
 
-<p>You can optionaally add a suffix, like <kbd>.html</kbd>, making the page appear to be of a certain type:</p>
+<p>You can optionally add a suffix, like <kbd>.html</kbd>, making the page appear to be of a certain type:</p>
 
 <code>www.your-site.com/index.php/products/view/shoes.html</code>
 
diff --git a/user_guide/general/views.html b/user_guide/general/views.html
index daba759..d4ccb51 100644
--- a/user_guide/general/views.html
+++ b/user_guide/general/views.html
@@ -173,7 +173,7 @@
 
 <p>Then load the page at the URL you've been using and you should see the variables replaced.</p>
 
-<p><strong>Note:</strong> Youl'll notice that in the example above we are using PHP's alternative syntax.  If you
+<p><strong>Note:</strong> You'll notice that in the example above we are using PHP's alternative syntax.  If you
 are not familiar with it you can read about it <a href="alternative_php.html">here</a>.</p>
 
 <h2>Creating Loops</h2>
